Zookeeper JavaAPI 基本的增删改查

创建节点

同步创建

/**
 * 同步创建节点
 */
@Test
public void create1() throws KeeperException, InterruptedException {
       /**
        * 第一个参数：节点的路径
        * 第二个参数：节点的数据
        * 第三个参数：权限列表 ZooDefs.Ids.OPEN_ACL_UNSAFE:world:anyone:cdrwa /
        * 第四个参数：节点的类子持久化节点
        */
       zooKeeper.create("/hello/gzh", "helloworld".getBytes(), ZooDefs.Ids.READ_ACL_UNSAFE, CreateMode.PERSISTENT);
}

World 授权模式

@Test
public void als1() throws KeeperException, InterruptedException {
        // world授权模式
        // 权限列表
        List<ACL> acls = new ArrayList<>();
        // 授权模式和授权对象
        Id id = new Id("world", "anyone");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.READ, id));
        acls.add(new ACL(ZooDefs.Perms.WRITE, id));
        zooKeeper.create("/hello/cl", "cl".getBytes(), acls, CreateMode.PERSISTENT);
}

IP 授权模式

@Test
public void als2() throws Exception {
        // IP授权模式
        // 权限列表
        List<ACL> acls = new ArrayList<>();
        // 授权模式和授权对象
        Id id = new Id("ip", "0.0.0.0");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL, id));
        zooKeeper.create("/hello/alsj", "cl".getBytes(), acls, CreateMode.PERSISTENT);
}

auth 授权模式

@Test
public void als3() throws Exception {
        // auth授权模式
        // 添加授权用户
        zooKeeper.addAuthInfo("digest", "root:070313".getBytes());
        // 权限列表
        List<ACL> acls = new ArrayList<>();
        // 授权模式和授权对象
        Id id = new Id("auth", "root");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL, id));
        zooKeeper.create("/hello/eh", "eel".getBytes(), acls, CreateMode.PERSISTENT);
}

digest 授权模式

@Test
public void als4() throws Exception {
        // digest授权模式
        // 权限列表
        List<ACL> acls = new ArrayList<>();
        // 授权模式和授权对象
        Id id = new Id("digest", "root:4d9PWRXHtxrRSgCIGCixNUZdTPQ=");
        // 权限设置
        acls.add(new ACL(ZooDefs.Perms.ALL, id));
        zooKeeper.create("/hello/cjk", "cls".getBytes(), acls, CreateMode.PERSISTENT);
}

异步创建节点

@Test
public void create2() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：节点的数据
         * 第三个参数：权限列表 ZooDefs.Ids.OPEN_ACL_UNSAFE:world:anyone:cdrwa /
         * 第四个参数：节点的类子持久化节点
         * 第五个参数：异步回调接口
         * 第六个参数：上下文参数
         */
        zooKeeper.create("/hello/xjp", "zhuxi".getBytes(), ZooDefs.Ids.READ_ACL_UNSAFE, CreateMode.PERSISTENT, new AsyncCallback.StringCallback() {
                @Override
                public void processResult(int rc, String path, Object ctx, String name) {
                        // 0 代表创建成功
                        System.out.println(rc);
                        // 节点的路径
                        System.out.println(path);
                        // 上下文的参数
                        System.out.println(ctx);
                        // 节点的路径
                        System.out.println(name);
                }
        }, "i am context");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("创建完成");
}

更新节点

同步更新数据

@Test
public void update1() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：修改的数据
         * 第三个参数：数据版本号 -1 代表版本号不参与更新
         * 第四个参数：异步回调接口
         * 第五个参数：上下文参数
         */ 
        Stat stat = zooKeeper.setData("/set/note1", "i love you".getBytes(), -1);
        System.out.println(stat);
}

异步更新数据

@Test
public void update2() {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：修改的数据
         * 第三个参数：数据版本号 -1 代表版本号不参与更新
         */
        zooKeeper.setData("/set/note1", "i love you2".getBytes(), -1, new AsyncCallback.StatCallback() {
                @Override
                public void processResult(int rc, String path, Object ctx, Stat stat) {
                        // 0 代表创建成功
                        System.out.println(rc);
                        // 节点的路径
                        System.out.println(path);
                        // 上下文的参数
                        System.out.println(ctx);
                        // 当前节点的详细信息
                        System.out.println(stat);
                }
        }, "i am context");
TimeUnit.SECONDS.sleep(1);
}

删除节点

同步删除数据

@Test
public void delete1() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：删除节点的路径
         * 第二个参数：数据版本信息，-1代表不考律版本信息
         */
        zooKeeper.delete("/delete/node1", -1);
}

异步删除数据

@Test
public void delete2() {
      /**
       * 第一个参数：删除节点的路径
       * 第二个参数：数据版本信息，-1代表不考律版本信息
       * 第三个参数：异步回调接口
       * 第四个参数：上下文参数
       */
      zooKeeper.delete("/delete/node2", -1, new AsyncCallback.VoidCallback() {
              @Override
              public void processResult(int rc, String path, Object ctx) {
                      // 0代表删除成功
                      System.out.println(rc);
                      // 删除节点的路径
                      System.out.println(path);
                      // 上下文参数
                      System.out.println(ctx);
              }
      }, "我是上下文参数");
      TimeUnit.SECONDS.sleep(1);
}

查询节点

同步查询数据

@Test
public void get1() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：是否启用监控 这里为false即可
         * 第三个参数：读取节点属性的对象
         */
        byte[] data = zooKeeper.getData("/delete", false, new Stat());
        System.out.println(new String(data));
}

异步查询数据

@Test
public void get2() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：是否启用监控 这里为false即可
         * 第三个参数：异步回调接口
         * 第四个参数：上下文参数
         */
        zooKeeper.getData("/delete", false, new AsyncCallback.DataCallback() {
                @Override
                public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
                        // 0代表读取成功
                        System.out.println(rc);
                        // 节点的路径
                        System.out.println(path);
                        // 上下文参数
                        System.out.println(ctx);
                        // 节点的详细信息
                        System.out.println(stat);
                }
        }, "我是上下文参数");
TimeUnit.SECONDS.sleep(1);
}

同步查询子节点

@Test
public void getChildren1() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：是否启用监控 这里为false即可
         */
        List<String> children = zooKeeper.getChildren("/hello", false);
        children.forEach(System.out::println);
}

异步查询子节点

@Test
public void getChildren2() throws InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：是否启用监控 这里为false即可
         * 第三个参数：异步回调接口
         * 第四个参数：上下文参数
         */
        zooKeeper.getChildren("/hello", false, new AsyncCallback.ChildrenCallback() {
                @Override
                public void processResult(int rc, String path, Object ctx, List<String> children) {
                        // 0代表读取成功
                        System.out.println(rc);
                        // 节点的路径
                        System.out.println(path);
                        // 上下文参数
                        System.out.println(ctx);
                        // 子节点集合
                        children.forEach(System.out::println);
                }
        }, "我是上下文参数");
        TimeUnit.SECONDS.sleep(1);
}

判断节点是否存在

同步判断

@Test
public void exists1() throws KeeperException, InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：是否启用监控 这里为false即可
         */
        Stat stat = zooKeeper.exists("/hello", false);
        System.out.println(stat);
}

异步判断

@Test
public void exists2() throws InterruptedException {
        /**
         * 第一个参数：节点的路径
         * 第二个参数：是否启用监控 这里为false即可
         * 第三个参数：异步回调接口
         * 第四个参数：上下文参数
         */
        zooKeeper.exists("/hello", false, new AsyncCallback.StatCallback() {
                @Override
                public void processResult(int rc, String path, Object ctx, Stat stat) {
                        // 0代表读取成功
                        System.out.println(rc);
                        // 节点的路径
                        System.out.println(path);
                        // 上下文参数
                        System.out.println(ctx);
                        // 节点的详细信息，如果为null则说明该节点不存在
                        System.out.println(stat);
                }
        }, "我是上下文参数");
        TimeUnit.SECONDS.sleep(1);
}